home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / PInterfaces / Slots.p < prev    next >
Encoding:
Text File  |  1994-07-17  |  12.1 KB  |  383 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Slots.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Slots;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __SLOTS__}
  27. {$SETC __SLOTS__ := 1}
  28.  
  29. {$I+}
  30. {$SETC SlotsIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __EVENTS__}
  40. {$I Events.p}
  41. {$ENDC}
  42. {    Quickdraw.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        QuickdrawText.p                                            }
  45. {    OSUtils.p                                                    }
  46.  
  47. {$IFC UNDEFINED __FILES__}
  48. {$I Files.p}
  49. {$ENDC}
  50.  
  51. {$PUSH}
  52. {$ALIGN MAC68K}
  53. {$LibExport+}
  54.  
  55. CONST
  56.     fCardIsChanged                = 1;                            {Card is Changed field in StatusFlags field of sInfoArray}
  57.     fCkForSame                    = 0;                            {For SearchSRT. Flag to check for SAME sResource in the table. }
  58.     fCkForNext                    = 1;                            {For SearchSRT. Flag to check for NEXT sResource in the table. }
  59.     fWarmStart                    = 2;                            {If this bit is set then warm start else cold start.}
  60.     stateNil                    = 0;                            {State}
  61.     stateSDMInit                = 1;                            {:Slot declaration manager Init}
  62.     statePRAMInit                = 2;                            {:sPRAM record init}
  63.     statePInit                    = 3;                            {:Primary init}
  64.     stateSInit                    = 4;                            {:Secondary init}
  65. { flags for spParamData }
  66.     fall                        = 0;                            { bit 0: set=search enabled/disabled sRsrc's }
  67.     foneslot                    = 1;                            {    1: set=search sRsrc's in given slot only }
  68.     fnext                        = 2;                            {    2: set=search for next sRsrc }
  69.  
  70. TYPE
  71.     {
  72.         SlotIntServiceProcPtr uses register based parameters on the 68k and cannot
  73.         be written in or called from a high-level language without the help of
  74.         mixed mode or assembly glue.
  75.  
  76.         In:
  77.          => sqParameter     A1.L
  78.         Out:
  79.          <= return value    D0.W
  80.     }
  81.     SlotIntServiceProcPtr = ProcPtr;  { FUNCTION SlotIntService(sqParameter: LONGINT): INTEGER; }
  82.     SlotIntServiceUPP = UniversalProcPtr;
  83.  
  84. CONST
  85.     uppSlotIntServiceProcInfo = $0000B822; { Register FUNCTION (4 bytes in A1): 2 bytes in D0; }
  86.  
  87. FUNCTION NewSlotIntServiceProc(userRoutine: SlotIntServiceProcPtr): SlotIntServiceUPP;
  88.     {$IFC NOT GENERATINGCFM }
  89.     INLINE $2E9F;
  90.     {$ENDC}
  91.  
  92. FUNCTION CallSlotIntServiceProc(sqParameter: LONGINT; userRoutine: SlotIntServiceUPP): INTEGER;
  93.     {$IFC NOT GENERATINGCFM}
  94.     {To be implemented:  Glue to move parameters into registers.}
  95.     {$ENDC}
  96.  
  97. TYPE
  98.     SlotIntQElement = RECORD
  99.         sqLink:                    Ptr;                                    {ptr to next element}
  100.         sqType:                    INTEGER;                                {queue type ID for validity}
  101.         sqPrio:                    INTEGER;                                {priority}
  102.         sqAddr:                    SlotIntServiceUPP;                        {interrupt service routine}
  103.         sqParm:                    LONGINT;                                {optional A1 parameter}
  104.     END;
  105.     SQElemPtr = ^SlotIntQElement;
  106.  
  107.     SpBlock = RECORD
  108.         spResult:                LONGINT;                                {FUNCTION Result}
  109.         spsPointer:                Ptr;                                    {structure pointer}
  110.         spSize:                    LONGINT;                                {size of structure}
  111.         spOffsetData:            LONGINT;                                {offset/data field used by sOffsetData}
  112.         spIOFileName:            Ptr;                                    {ptr to IOFile name for sDisDrvrName}
  113.         spsExecPBlk:            Ptr;                                    {pointer to sExec parameter block.}
  114.         spParamData:            LONGINT;                                {misc parameter data (formerly spStackPtr).}
  115.         spMisc:                    LONGINT;                                {misc field for SDM.}
  116.         spReserved:                LONGINT;                                {reserved for future expansion}
  117.         spIOReserved:            INTEGER;                                {Reserved field of Slot Resource Table}
  118.         spRefNum:                INTEGER;                                {RefNum}
  119.         spCategory:                INTEGER;                                {sType: Category}
  120.         spCType:                INTEGER;                                {Type}
  121.         spDrvrSW:                INTEGER;                                {DrvrSW}
  122.         spDrvrHW:                INTEGER;                                {DrvrHW}
  123.         spTBMask:                SInt8;                                    {type bit mask bits 0..3 mask words 0..3}
  124.         spSlot:                    SInt8;                                    {slot number}
  125.         spID:                    SInt8;                                    {structure ID}
  126.         spExtDev:                SInt8;                                    {ID of the external device}
  127.         spHwDev:                SInt8;                                    {Id of the hardware device.}
  128.         spByteLanes:            SInt8;                                    {bytelanes from card ROM format block}
  129.         spFlags:                SInt8;                                    {standard flags}
  130.         spKey:                    SInt8;                                    {Internal use only}
  131.     END;
  132.     SpBlockPtr = ^SpBlock;
  133.  
  134.     SInfoRecord = RECORD
  135.         siDirPtr:                Ptr;                                    {Pointer to directory}
  136.         siInitStatusA:            INTEGER;                                {initialization E}
  137.         siInitStatusV:            INTEGER;                                {status returned by vendor init code}
  138.         siState:                SInt8;                                    {initialization state}
  139.         siCPUByteLanes:            SInt8;                                    {0=[d0..d7] 1=[d8..d15]}
  140.         siTopOfROM:                SInt8;                                    {Top of ROM= $FssFFFFx: x is TopOfROM}
  141.         siStatusFlags:            SInt8;                                    {bit 0 - card is changed}
  142.         siTOConst:                INTEGER;                                {Time Out C for BusErr}
  143.         siReserved:                ARRAY [0..1] OF SInt8;                    {reserved}
  144.         siROMAddr:                Ptr;                                    { addr of top of ROM }
  145.         siSlot:                    SInt8;                                    { slot number }
  146.         siPadding:                ARRAY [0..2] OF SInt8;                    { reserved }
  147.     END;
  148.     SInfoRecPtr = ^SInfoRecord;
  149.  
  150.     SDMRecord = RECORD
  151.         sdBEVSave:                ProcPtr;                                {Save old BusErr vector}
  152.         sdBusErrProc:            ProcPtr;                                {Go here to determine if it is a BusErr}
  153.         sdErrorEntry:            ProcPtr;                                {Go here if BusErrProc finds real BusErr}
  154.         sdReserved:                LONGINT;                                {Reserved}
  155.     END;
  156.     FHeaderRec = RECORD
  157.         fhDirOffset:            LONGINT;                                {offset to directory}
  158.         fhLength:                LONGINT;                                {length of ROM}
  159.         fhCRC:                    LONGINT;                                {CRC}
  160.         fhROMRev:                SInt8;                                    {revision of ROM}
  161.         fhFormat:                SInt8;                                    {format - 2}
  162.         fhTstPat:                LONGINT;                                {test pattern}
  163.         fhReserved:                SInt8;                                    {reserved}
  164.         fhByteLanes:            SInt8;                                    {ByteLanes}
  165.     END;
  166.     FHeaderRecPtr = ^FHeaderRec;
  167.  
  168.     SEBlock = PACKED RECORD
  169.         seSlot:                    UInt8;                                    {Slot number.}
  170.         sesRsrcId:                UInt8;                                    {sResource Id.}
  171.         seStatus:                INTEGER;                                {Status of code executed by sExec.}
  172.         seFlags:                UInt8;                                    {Flags}
  173.         seFiller0:                UInt8;                                    {Filler, must be SignedByte to align on odd boundry}
  174.         seFiller1:                UInt8;                                    {Filler}
  175.         seFiller2:                UInt8;                                    {Filler}
  176.         seResult:                LONGINT;                                {Result of sLoad.}
  177.         seIOFileName:            LONGINT;                                {Pointer to IOFile name.}
  178.         seDevice:                UInt8;                                    {Which device to read from.}
  179.         sePartition:            UInt8;                                    {The partition.}
  180.         seOSType:                UInt8;                                    {Type of OS.}
  181.         seReserved:                UInt8;                                    {Reserved field.}
  182.         seRefNum:                UInt8;                                    {RefNum of the driver.}
  183.         seNumDevices:            UInt8;                                    { Number of devices to load.}
  184.         seBootState:            UInt8;                                    {State of StartBoot code.}
  185.     END;
  186. {  Principle  }
  187.  
  188. FUNCTION SReadByte(spBlkPtr: SpBlockPtr): OSErr;
  189.     {$IFC NOT GENERATINGCFM}
  190.     INLINE $205F, $7000, $A06E, $3E80;
  191.     {$ENDC}
  192. FUNCTION SReadWord(spBlkPtr: SpBlockPtr): OSErr;
  193.     {$IFC NOT GENERATINGCFM}
  194.     INLINE $205F, $7001, $A06E, $3E80;
  195.     {$ENDC}
  196. FUNCTION SReadLong(spBlkPtr: SpBlockPtr): OSErr;
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $205F, $7002, $A06E, $3E80;
  199.     {$ENDC}
  200. FUNCTION SGetCString(spBlkPtr: SpBlockPtr): OSErr;
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $205F, $7003, $A06E, $3E80;
  203.     {$ENDC}
  204. FUNCTION SGetBlock(spBlkPtr: SpBlockPtr): OSErr;
  205.     {$IFC NOT GENERATINGCFM}
  206.     INLINE $205F, $7005, $A06E, $3E80;
  207.     {$ENDC}
  208. FUNCTION SFindStruct(spBlkPtr: SpBlockPtr): OSErr;
  209.     {$IFC NOT GENERATINGCFM}
  210.     INLINE $205F, $7006, $A06E, $3E80;
  211.     {$ENDC}
  212. FUNCTION SReadStruct(spBlkPtr: SpBlockPtr): OSErr;
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $205F, $7007, $A06E, $3E80;
  215.     {$ENDC}
  216. {  Special  }
  217. FUNCTION SReadInfo(spBlkPtr: SpBlockPtr): OSErr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $205F, $7010, $A06E, $3E80;
  220.     {$ENDC}
  221. FUNCTION SReadPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $205F, $7011, $A06E, $3E80;
  224.     {$ENDC}
  225. FUNCTION SPutPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $205F, $7012, $A06E, $3E80;
  228.     {$ENDC}
  229. FUNCTION SReadFHeader(spBlkPtr: SpBlockPtr): OSErr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $205F, $7013, $A06E, $3E80;
  232.     {$ENDC}
  233. FUNCTION SNextSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $205F, $7014, $A06E, $3E80;
  236.     {$ENDC}
  237. FUNCTION SNextTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $205F, $7015, $A06E, $3E80;
  240.     {$ENDC}
  241. FUNCTION SRsrcInfo(spBlkPtr: SpBlockPtr): OSErr;
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $205F, $7016, $A06E, $3E80;
  244.     {$ENDC}
  245. FUNCTION SCkCardStat(spBlkPtr: SpBlockPtr): OSErr;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $205F, $7018, $A06E, $3E80;
  248.     {$ENDC}
  249. FUNCTION SReadDrvrName(spBlkPtr: SpBlockPtr): OSErr;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $205F, $7019, $A06E, $3E80;
  252.     {$ENDC}
  253. FUNCTION SFindDevBase(spBlkPtr: SpBlockPtr): OSErr;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $205F, $701B, $A06E, $3E80;
  256.     {$ENDC}
  257. FUNCTION SFindBigDevBase(spBlkPtr: SpBlockPtr): OSErr;
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $205F, $701C, $A06E, $3E80;
  260.     {$ENDC}
  261. {  Advanced  }
  262. FUNCTION InitSDeclMgr(spBlkPtr: SpBlockPtr): OSErr;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $205F, $7020, $A06E, $3E80;
  265.     {$ENDC}
  266. FUNCTION SPrimaryInit(spBlkPtr: SpBlockPtr): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $205F, $7021, $A06E, $3E80;
  269.     {$ENDC}
  270. FUNCTION SCardChanged(spBlkPtr: SpBlockPtr): OSErr;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $205F, $7022, $A06E, $3E80;
  273.     {$ENDC}
  274. FUNCTION SExec(spBlkPtr: SpBlockPtr): OSErr;
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $205F, $7023, $A06E, $3E80;
  277.     {$ENDC}
  278. FUNCTION SOffsetData(spBlkPtr: SpBlockPtr): OSErr;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $205F, $7024, $A06E, $3E80;
  281.     {$ENDC}
  282. FUNCTION SInitPRAMRecs(spBlkPtr: SpBlockPtr): OSErr;
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $205F, $7025, $A06E, $3E80;
  285.     {$ENDC}
  286. FUNCTION SReadPBSize(spBlkPtr: SpBlockPtr): OSErr;
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $205F, $7026, $A06E, $3E80;
  289.     {$ENDC}
  290. FUNCTION SCalcStep(spBlkPtr: SpBlockPtr): OSErr;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $205F, $7028, $A06E, $3E80;
  293.     {$ENDC}
  294. FUNCTION SInitSRsrcTable(spBlkPtr: SpBlockPtr): OSErr;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $205F, $7029, $A06E, $3E80;
  297.     {$ENDC}
  298. FUNCTION SSearchSRT(spBlkPtr: SpBlockPtr): OSErr;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $205F, $702A, $A06E, $3E80;
  301.     {$ENDC}
  302. FUNCTION SUpdateSRT(spBlkPtr: SpBlockPtr): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $205F, $702B, $A06E, $3E80;
  305.     {$ENDC}
  306. FUNCTION SCalcSPointer(spBlkPtr: SpBlockPtr): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $205F, $702C, $A06E, $3E80;
  309.     {$ENDC}
  310. FUNCTION SGetDriver(spBlkPtr: SpBlockPtr): OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $205F, $702D, $A06E, $3E80;
  313.     {$ENDC}
  314. FUNCTION SPtrToSlot(spBlkPtr: SpBlockPtr): OSErr;
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $205F, $702E, $A06E, $3E80;
  317.     {$ENDC}
  318. FUNCTION SFindSInfoRecPtr(spBlkPtr: SpBlockPtr): OSErr;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $205F, $702F, $A06E, $3E80;
  321.     {$ENDC}
  322. FUNCTION SFindSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $205F, $7030, $A06E, $3E80;
  325.     {$ENDC}
  326. FUNCTION SDeleteSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $205F, $7031, $A06E, $3E80;
  329.     {$ENDC}
  330. FUNCTION OpenSlot(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  331. FUNCTION OpenSlotSync(paramBlock: ParmBlkPtr): OSErr;
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $205F, $A200, $3E80;
  334.     {$ENDC}
  335. FUNCTION OpenSlotAsync(paramBlock: ParmBlkPtr): OSErr;
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $205F, $A600, $3E80;
  338.     {$ENDC}
  339. {  Device Manager Slot Support  }
  340. FUNCTION SIntInstall(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  341.     {$IFC NOT GENERATINGCFM}
  342.     INLINE $301F, $205F, $A075, $3E80;
  343.     {$ENDC}
  344. FUNCTION SIntRemove(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $301F, $205F, $A076, $3E80;
  347.     {$ENDC}
  348. FUNCTION SVersion(spBlkPtr: SpBlockPtr): OSErr;
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $205F, $7008, $A06E, $3E80;
  351.     {$ENDC}
  352. FUNCTION SetSRsrcState(spBlkPtr: SpBlockPtr): OSErr;
  353.     {$IFC NOT GENERATINGCFM}
  354.     INLINE $205F, $7009, $A06E, $3E80;
  355.     {$ENDC}
  356. FUNCTION InsertSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  357.     {$IFC NOT GENERATINGCFM}
  358.     INLINE $205F, $700A, $A06E, $3E80;
  359.     {$ENDC}
  360. FUNCTION SGetSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  361.     {$IFC NOT GENERATINGCFM}
  362.     INLINE $205F, $700B, $A06E, $3E80;
  363.     {$ENDC}
  364. FUNCTION SGetTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $205F, $700C, $A06E, $3E80;
  367.     {$ENDC}
  368. FUNCTION SGetSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $205F, $701D, $A06E, $3E80;
  371.     {$ENDC}
  372.  
  373. {$ALIGN RESET}
  374. {$POP}
  375.  
  376. {$SETC UsingIncludes := SlotsIncludes}
  377.  
  378. {$ENDC} {__SLOTS__}
  379.  
  380. {$IFC NOT UsingIncludes}
  381.  END.
  382. {$ENDC}
  383.